package com.ruoyi.rebateRule.service.impl;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.alibaba.fastjson.JSON;
import com.ruoyi.common.utils.uuid.IdUtils;
import com.ruoyi.distributionLog.domain.DistributionLog;
import com.ruoyi.distributionLog.service.IDistributionLogService;
import com.ruoyi.distributor.domain.DistributionUser;
import com.ruoyi.distributor.service.IDistributionUserService;
import com.ruoyi.income.domain.DistributionIncome;
import com.ruoyi.income.service.IDistributionIncomeService;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.distributor.service.impl.DistributionUserServiceImpl;
import com.ruoyi.relation.domain.DistributionRelation;
import com.ruoyi.relation.service.IDistributionRelationService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.rebateRule.mapper.RebateRuleMapper;
import com.ruoyi.rebateRule.domain.RebateRule;
import com.ruoyi.rebateRule.service.IRebateRuleService;
import org.springframework.transaction.annotation.Transactional;

/**
 * 返佣规则Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-10-11
 */
@Service
public class RebateRuleServiceImpl implements IRebateRuleService 
{
    private static final Logger log = LoggerFactory.getLogger(RebateRuleServiceImpl.class);

    @Autowired
    private RebateRuleMapper rebateRuleMapper;

    @Autowired
    private IDistributionIncomeService distributionIncomeService;

    @Autowired
    private IDistributionUserService distributionUserService;

    @Autowired
    private IDistributionLogService distributionLogService;

    @Autowired
    private IDistributionRelationService distributionRelationService;

    @Autowired
    private IRebateRuleService rebateRuleService;



//    /**
//     * 订单支付成功后触发返佣流程
//     *
//     * @param order 订单信息
//     */
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void processRebateOnOrderPaid(Order order) {
//        try {
//            log.info("开始处理订单返佣，订单ID: {}, 订单编号: {}", order.getOrderId(), order.getOrderCode());
//
//            // 1. 获取下单用户ID（从订单中获取分销员ID）
//            Long userId = order.getUserId();
//            if (userId == null) {
//                log.warn("订单用户ID为空，无法处理返佣，订单ID: {}", order.getOrderId());
//                return;
//            }
//
//            // 2. 查询下单用户的分销员信息
//            DistributionUser buyerDistributor = distributionUserService.selectDistributionUserByUserId(userId);
//            if (buyerDistributor == null) {
//                log.info("下单用户不是分销员，无需处理返佣，用户ID: {}", userId);
//                return;
//            }
//
//            // 3. 查询下单用户的上级分销员
//            List<DistributionRelation> superiorRelations = findValidSuperiorRelations(buyerDistributor.getDistributorId());
//            if (superiorRelations.isEmpty()) {
//                log.info("该分销员没有有效的上级，无需处理返佣，分销员ID: {}", buyerDistributor.getDistributorId());
//                return;
//            }
//
//            // 4. 为每个符合条件的上级匹配返佣规则并生成返佣记录
//            for (DistributionRelation relation : superiorRelations) {
//                processRebateForSuperior(order, relation);
//            }
//
//            log.info("订单返佣处理完成，订单ID: {}", order.getOrderId());
//        } catch (Exception e) {
//            log.error("处理订单返佣时发生异常，订单ID: {}", order.getOrderId(), e);
//            throw new RuntimeException("订单返佣处理失败", e);
//        }
//    }

    /**
     * 查询下单用户的有效上级分销员
     *
     * @param distributorId 下单分销员ID
     * @return 有效上级关系列表
     */
    private List<DistributionRelation> findValidSuperiorRelations(Long distributorId) {
        // 查询所有上级关系
        List<DistributionRelation> allRelations = distributionRelationService.selectDistributionRelationList(new DistributionRelation());

        // 筛选有效的上级关系：
        // 1. 下级是当前分销员
        // 2. 关系有效（del_flag=0）
        // 3. 关系层级匹配
        // 4. 上级状态正常
        return allRelations.stream()
                .filter(relation -> relation.getSubordinateId() != null && relation.getSubordinateId().equals(distributorId))
                .filter(relation -> "0".equals(relation.getDelFlag())) // 有效关系
                .filter(relation -> relation.getRelationLevel() != null) // 层级匹配
                .filter(relation -> {
                    // 检查上级状态
                    DistributionUser superior = distributionUserService.selectDistributionUserByDistributorId(relation.getDistributorId());
                    return superior != null && "0".equals(superior.getStatus()) && "0".equals(superior.getDelFlag());
                })
                .collect(Collectors.toList());
    }

//    /**
//     * 为上级分销员处理返佣
//     *
//     * @param order 订单信息
//     * @param relation 分销关系
//     */
//    private void processRebateForSuperior(Order order, DistributionRelation relation) {
//        try {
//            // 1. 获取上级分销员信息
//            DistributionUser superiorDistributor = distributionUserService.selectDistributionUserByDistributorId(relation.getDistributorId());
//            if (superiorDistributor == null) {
//                log.warn("上级分销员不存在，分销员ID: {}", relation.getDistributorId());
//                return;
//            }
//
//            // 2. 匹配返佣规则
//            RebateRule matchedRule = matchRebateRule(order, superiorDistributor, relation.getRelationLevel());
//            if (matchedRule == null) {
//                log.info("未找到匹配的返佣规则，上级分销员ID: {}, 订单ID: {}", relation.getDistributorId(), order.getOrderId());
//                return;
//            }
//
//            // 3. 生成待计算返佣记录
//            DistributionIncome income = createDistributionIncome(order, superiorDistributor, matchedRule);
//            distributionIncomeService.insertDistributionIncome(income);
//
//            // 4. 记录返佣触发日志
//            recordRebateTriggerLog(order, superiorDistributor, matchedRule);
//
//            log.info("成功为上级分销员生成返佣记录，上级分销员ID: {}, 订单ID: {}, 规则ID: {}",
//                    relation.getDistributorId(), order.getOrderId(), matchedRule.getRuleId());
//        } catch (Exception e) {
//            log.error("为上级分销员处理返佣时发生异常，上级分销员ID: {}, 订单ID: {}",
//                    relation.getDistributorId(), order.getOrderId(), e);
//        }
//    }

//    /**
//     * 匹配返佣规则
//     *
//     * @param order 订单信息
//     * @param distributor 上级分销员
//     * @param relationLevel 关系层级
//     * @return 匹配的返佣规则，未匹配到则返回null
//     */
//    private RebateRule matchRebateRule(Order order, DistributionUser distributor, String relationLevel) {
//        // 构造查询条件
//        RebateRule queryRule = new RebateRule();
//        queryRule.setProductType("1"); // 自助餐券
//        queryRule.setGradeId(distributor.getGradeId()); // 等级匹配
//        queryRule.setRelationLevel(relationLevel); // 层级匹配
//        queryRule.setStatus("0"); // 规则状态正常
//        queryRule.setDelFlag("0"); // 未删除
//
//        // 查询符合条件的规则
//        List<RebateRule> candidateRules = rebateRuleService.selectRebateRuleList(queryRule);
//
//        // 进一步筛选：规则生效时间范围内且满足金额门槛
//        Date now = new Date();
//        return candidateRules.stream()
//                .filter(rule -> rule.getValidTimeStart() != null && !rule.getValidTimeStart().after(now)) // 生效时间<=当前时间
//                .filter(rule -> rule.getValidTimeEnd() != null && !rule.getValidTimeEnd().before(now)) // 失效时间>=当前时间
//                .filter(rule -> rule.getMinOrderAmount() != null &&
//                        order.getTotalAmount() != null &&
//                        order.getTotalAmount().compareTo(rule.getMinOrderAmount()) >= 0) // 订单金额>=最低金额门槛
//                .findFirst()
//                .orElse(null);
//    }

//    /**
//     * 创建待计算返佣记录
//     *
//     * @param order 订单信息
//     * @param distributor 上级分销员
//     * @param rule 匹配的返佣规则
//     * @return 返佣记录
//     */
//    private DistributionIncome createDistributionIncome(Order order, DistributionUser distributor, RebateRule rule) {
//        DistributionIncome income = new DistributionIncome();
//
//        // 必传字段
//        income.setOrderId(order.getOrderId()); // 订单ID
//        income.setOrderCode(order.getOrderCode()); // 订单编号
//        // TODO: 商品ID需要从订单详情中获取，这里暂时设为null，需要根据实际业务逻辑调整
//        income.setGoodsId(null); // 商品ID
//        income.setDistributorId(distributor.getDistributorId()); // 上级分销员ID
//        income.setRuleId(rule.getRuleId()); // 规则ID
//        income.setOrderAmount(order.getTotalAmount()); // 订单实付金额
//        income.setCommissionBase(order.getTotalAmount()); // 佣金计算基数（默认为订单实付金额）
//        income.setIncomeStatus("0"); // 待计算
//
//        // 可选字段
//        income.setStatus("0"); // 状态正常
//        income.setDelFlag("0"); // 未删除
//
//        return income;
//    }

//    /**
//     * 记录返佣触发日志
//     *
//     * @param order 订单信息
//     * @param distributor 上级分销员
//     * @param rule 匹配的返佣规则
//     */
//    private void recordRebateTriggerLog(Order order, DistributionUser distributor, RebateRule rule) {
//        try {
//            DistributionLog logEntry = new DistributionLog();
//
//            // 基本信息
//            logEntry.setDistributorId(distributor.getDistributorId()); // 分销员ID
//            logEntry.setLogType("3"); // 返佣日志类型
//            logEntry.setAction("订单触发返佣"); // 操作动作
//            logEntry.setSourceCode(order.getOrderCode()); // 来源单号（订单编号）
//            logEntry.setStatus("0"); // 状态正常
//            logEntry.setDelFlag("0"); // 未删除
//
//            // 构造变更详情
//            Map<String, Object> changeDetail = new HashMap<>();
//            changeDetail.put("orderId", order.getOrderId());
//            changeDetail.put("orderCode", order.getOrderCode());
//            changeDetail.put("orderAmount", order.getTotalAmount());
//            changeDetail.put("ruleId", rule.getRuleId());
//            changeDetail.put("ruleName", rule.getRuleName());
//            logEntry.setChangeDetail(JSON.toJSONString(changeDetail)); // 变更详情（JSON格式）
//
//            // 设置日志编码
//            logEntry.setLogCode(IdUtils.generateLogCode());
//
//            // 插入日志
//            distributionLogService.insertDistributionLog(logEntry);
//        } catch (Exception e) {
//            log.error("记录返佣触发日志时发生异常，分销员ID: {}, 订单ID: {}",
//                    distributor.getDistributorId(), order.getOrderId(), e);
//        }
//    }



    /* ====================== 查询返佣规则 ==================== */

    /**
     * 查询返佣规则
     * 
     * @param ruleId 返佣规则主键
     * @return 返佣规则
     */
    @Override
    public RebateRule selectRebateRuleByRuleId(Long ruleId)
    {
        return rebateRuleMapper.selectRebateRuleByRuleId(ruleId);
    }

    /**
     * 查询返佣规则列表
     * 
     * @param rebateRule 返佣规则
     * @return 返佣规则
     */
    @Override
    public List<RebateRule> selectRebateRuleList(RebateRule rebateRule)
    {
        return rebateRuleMapper.selectRebateRuleList(rebateRule);
    }

    /**
     * 新增返佣规则
     * 
     * @param rebateRule 返佣规则
     * @return 结果
     */
    @Override
    public int insertRebateRule(RebateRule rebateRule)
    {
        rebateRule.setCreateTime(DateUtils.getNowDate());
        return rebateRuleMapper.insertRebateRule(rebateRule);
    }

    /**
     * 修改返佣规则
     * 
     * @param rebateRule 返佣规则
     * @return 结果
     */
    @Override
    public int updateRebateRule(RebateRule rebateRule)
    {
        rebateRule.setUpdateTime(DateUtils.getNowDate());
        return rebateRuleMapper.updateRebateRule(rebateRule);
    }

    /**
     * 批量删除返佣规则
     * 
     * @param ruleIds 需要删除的返佣规则主键
     * @return 结果
     */
    @Override
    public int deleteRebateRuleByRuleIds(Long[] ruleIds)
    {
        return rebateRuleMapper.deleteRebateRuleByRuleIds(ruleIds);
    }

    /**
     * 删除返佣规则信息
     * 
     * @param ruleId 返佣规则主键
     * @return 结果
     */
    @Override
    public int deleteRebateRuleByRuleId(Long ruleId)
    {
        return rebateRuleMapper.deleteRebateRuleByRuleId(ruleId);
    }
}
